
package Main;

import Exacto.Exacto;
import dgbi.BiGrafo;
import constructiva.Constructiva;
import Local.local;
import java.util.ArrayList;
import java.io.*;

/*
#Nodos Fijos en cada particion
5
12
20

%Nodos Nuevos en cada particion
0.6 (menos 40% menos)
1 (igual)
1.4 (mayor, 40% mas)

%ejes
20
50
80

#iteraciones grasp
5
10
15
20

%goloso
20
50
80
 
 */


public class Main {
    public static void main(String[] args) throws IOException
    {

//        ArrayList<dgbi.BiGrafo> bigConstructiv = new ArrayList<dgbi.BiGrafo>();
//        
//        Gen.Gen2(5, 5, 5, 5, 30, 1);
//        bigConstructiv=Parser.Parser();
//        dgbi.BiGrafo big1= new BiGrafo();
//        dgbi.BiGrafo big2= new BiGrafo();
//        dgbi.BiGrafo big3= new BiGrafo();
//        dgbi.BiGrafo big4= new BiGrafo();
//        big1.copiar(bigConstructiv.get(0));
//        big2.copiar(bigConstructiv.get(0));
//        big3.copiar(bigConstructiv.get(0));
//        big4.copiar(bigConstructiv.get(0));
//        Constructiva ct=new Constructiva();
//        ct.ContructivaAlgoGrasp(big1, 10);
//        ct.ContructivaAlgoGrasp(big2, 20);
//        ct.ContructivaAlgoGrasp(big3, 50);
//        ct.ContructivaAlgoGrasp(big4, 80);
        
        System.out.println(" TP3 - Algoritmos Estructuras de Datos 3 - Grupo 15 ");
        ArrayList<dgbi.BiGrafo> bigConstructiva = new ArrayList<dgbi.BiGrafo>();
        bigConstructiva=Parser.Parser();
        System.out.println(" 1) Correr exacto para todos los casos leidos del archivo");
        System.out.println(" 2) Correr goloso para todos los casos leidos del archivo");
        System.out.println(" 3) Correr local para todos los casos leidos del archivo");
        System.out.println(" 4) Correr Grasp para todos los casos leidos del archivo");
        System.out.println(" 5) Salir");
        System.out.println("");
        char i = (char) System.in.read();
        int j=0;
        switch(i)
        {
            case '1':
                Exacto ex = new Exacto();
                while (j<bigConstructiva.size())
                {
                    ex.Exacto(bigConstructiva.get(j));
                    j++;
                }
                Parser.ImprimirSalidaExacto(bigConstructiva);
            break;
            case '2':
                Constructiva constr = new Constructiva();
                while (j<bigConstructiva.size())
                {
                    constr.ContructivaAlgo(bigConstructiva.get(j));
                    j++;
                }
                Parser.ImprimirSalidaConstructiva(bigConstructiva);
            break;
            case '3':
                local loc = new local();
                while (j<bigConstructiva.size())
                {
                    loc.Busqlocal(bigConstructiva.get(j));
                    j++;
                }
                Parser.ImprimirSalidaLocal(bigConstructiva);
            break;
            case '4':
                grasp.Grasp grasp = new grasp.Grasp();
                while (j<bigConstructiva.size())
                {
                    grasp.grasp(bigConstructiva.get(j));
                    j++;
                }
                Parser.ImprimirSalidaGrasp(bigConstructiva);
            break;
            default:
                System.out.println("La opción elegida no se encuentra dentro del rango de las opciones disponibles.");
            break;
        }
        System.exit(0);
        
        double tiempoInicio ;
        double tiempoFinal ;
        double tiempo ;
        /* Cantidad de fijos */
        int[] aumentoNodosFijos= new int[3];
        aumentoNodosFijos[0]=5;
        aumentoNodosFijos[1]=12;
        aumentoNodosFijos[2]=20;
        /* Cantidad % de ejes */
        int[] aumentoNodosNuevos=new int[3];
        aumentoNodosNuevos[0]=80;
        aumentoNodosNuevos[1]=50;
        aumentoNodosNuevos[2]=80;
        /* Cantidad de grasp */
        int[] cantidadDeIteraciones=new int[3];
        cantidadDeIteraciones[0]=5;
        cantidadDeIteraciones[1]=10;
        cantidadDeIteraciones[2]=15;
        /* Porcentajes de goloso */
        int[] porcentajeGolosoGrasp=new int[6];
        porcentajeGolosoGrasp[0]=1;
        porcentajeGolosoGrasp[1]=20;
        porcentajeGolosoGrasp[2]=40;
        porcentajeGolosoGrasp[3]=60;
        porcentajeGolosoGrasp[4]=80;
        porcentajeGolosoGrasp[5]=100;
        //porcentajeGolosoGrasp[6]=100;
        /* Cantidad de nodos nuevos */
        double cantNodosNuevos=1.4;
        
        //ArrayList<dgbi.BiGrafo> bigConstructiva = new ArrayList<dgbi.BiGrafo>();
        ArrayList<dgbi.BiGrafo> big = new ArrayList<dgbi.BiGrafo>();
        int it1=0;
        
        while (it1<aumentoNodosFijos.length-1)
        {
            int it2=0;
            while(it2<aumentoNodosNuevos.length-2)
            {
                int cantidadDeNuevosNodos=(int) Math.round(aumentoNodosFijos[it1]*cantNodosNuevos);
                Gen.Gen2(aumentoNodosFijos[it1], aumentoNodosFijos[it1], cantidadDeNuevosNodos, cantidadDeNuevosNodos, aumentoNodosNuevos[it2],1);
                System.out.println("Fin generador");
                File test = new File("Test"+aumentoNodosFijos[it1]+"-"+aumentoNodosNuevos[it2]+".out");
                FileOutputStream testStream = new FileOutputStream(test);
                PrintStream salidaTest = new PrintStream(testStream);                
                int it4=0;
                while(it4<porcentajeGolosoGrasp.length)
                {
                    bigConstructiva =Parser.Parser();                        
                    grasp.Grasp grasp = new grasp.Grasp();
                    grasp.grasp(bigConstructiva.get(0), porcentajeGolosoGrasp[it4], salidaTest);
                    it4++;
                }
                it2++;
                testStream.close();
            }
            it1++;
        }
    }
}
